from torchvision import models
from PIL import Image
import matplotlib.pyplot as plt
import torch
import numpy as np
import torchvision.transforms as transforms
from torchvision.models.segmentation import DeepLabV3_ResNet101_Weights

def get_img_with_arr(img_path, as_binary=False):
    img_original = Image.open(img_path).convert('RGB')# Convert to RGB to avoid 4 channel problems
    img_original_arr = np.array(img_original)
    if(as_binary):
        img_original_arr = img_original.convert('1')
    return (img_original, img_original_arr)

def load_model():
    model = models.segmentation.deeplabv3_resnet101(weights=DeepLabV3_ResNet101_Weights.DEFAULT)
    model.eval()
    return model

def semantic_segmentation(model, img_path, min_prob = 0.90):
    # Load image
    img_original, _ = get_img_with_arr(img_path)

    # Configure the model
    preprocess = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean = [0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])])
    input_batch = preprocess(img_original).unsqueeze(0)

    # Use cuda if available
    if torch.cuda.is_available():
        input_batch = input_batch.to('cuda')
        model.to('cuda')

    with torch.no_grad():
        output = model(input_batch)['out']

    # Convert to probabilities (value between 0 and 1), cars only
    car_index = 7
    car_prob = output[0][car_index].sigmoid()

    # Select pixels where probability of being a car is > min_prob
    mask_binary = (car_prob > min_prob).cpu().numpy().astype(np.uint8)

    return (img_original, mask_binary)

def show_images(img_original, img_gt, img_pred):
    # Display images side by side
    plt.figure(figsize=(20, 5), num='Semantic Segmentation')

    for index, img in enumerate([img_original, img_gt, img_pred]):
        plt.subplot(1, 3, index+1)
        plt.title(img['title'])
        plt.imshow(img['img_data'], cmap=plt.cm.gray)
        plt.axis('off')

    plt.show()

def calculate_iou(pred, gt):
    intersection = np.logical_and(pred, gt).sum()
    union = np.logical_or(pred, gt).sum()
    return intersection / union    

model = load_model()

# Get segmentation mask images
car1, pred_mask_car_arr1 = semantic_segmentation(model, './images/car1.png')
car2, pred_mask_car_arr2 = semantic_segmentation(model, './images/car2.png')
car3, pred_mask_car_arr3 = semantic_segmentation(model, './images/car3.png')

# Load ground truth images
_, gt_mask_car_arr1 = get_img_with_arr('./images/car1_ground_truth.png', as_binary=True)
_, gt_mask_car_arr2 = get_img_with_arr('./images/car2_ground_truth.png', as_binary=True)
_, gt_mask_car_arr3 = get_img_with_arr('./images/car3_ground_truth.png', as_binary=True)

# Ground Truth - Calculate Intersection over Union
print('Intersection over Union -> car1: ' + str(calculate_iou(pred_mask_car_arr1, gt_mask_car_arr1)))
print('Intersection over Union -> car2: ' + str(calculate_iou(pred_mask_car_arr2, gt_mask_car_arr2)))
print('Intersection over Union -> car3: ' + str(calculate_iou(pred_mask_car_arr3, gt_mask_car_arr3)))

# Display original images and masks
show_images({ 'title': 'Car 1 - Original', 'img_data': car1 }, { 'title': 'Car 1 - Ground truth mask', 'img_data': gt_mask_car_arr1 }, { 'title': 'Car 1 - Segmentation mask', 'img_data': pred_mask_car_arr1})
show_images({ 'title': 'Car 2 - Original', 'img_data': car2 }, { 'title': 'Car 2 - Ground truth mask', 'img_data': gt_mask_car_arr2 }, { 'title': 'Car 2 - Segmentation mask', 'img_data': pred_mask_car_arr2})
show_images({ 'title': 'Car 3 - Original', 'img_data': car3 }, { 'title': 'Car 3 - Ground truth mask', 'img_data': gt_mask_car_arr3 }, { 'title': 'Car 3 - Segmentation mask', 'img_data': pred_mask_car_arr3})

Intersection over Union -> car1: 0.40552312612413766
Intersection over Union -> car2: 0.8858075943761763
Intersection over Union -> car3: 0.2905132270863938

# Get segmentation mask image
car1, pred_mask_car_arr1 = semantic_segmentation(model, './images/car1.png', min_prob=0.95)
car1_vertical, pred_mask_car_vertical_arr1 = semantic_segmentation(model, './images/car1_vertical.png', min_prob=0.95)

# Load ground truth image
_, gt_mask_car_vertical_arr1 = get_img_with_arr('./images/car1_vertical_ground_truth.png', as_binary=True)

# Ground Truth - Calculate Intersection over Union
print('Intersection over Union -> car1         : ' + str(calculate_iou(pred_mask_car_arr1, gt_mask_car_arr1)))
print('Intersection over Union -> car1 vertical: ' + str(calculate_iou(pred_mask_car_vertical_arr1, gt_mask_car_vertical_arr1)))

# Display original image and masks
show_images({ 'title': 'Car 1 - Original', 'img_data': car1 }, { 'title': 'Car 1 - Ground truth mask', 'img_data': gt_mask_car_arr1 }, { 'title': 'Car 1 - Segmentation mask', 'img_data': pred_mask_car_arr1})
show_images({ 'title': 'Car 1 Vertical - Original', 'img_data': car1_vertical }, { 'title': 'Car 1 Vertical - Ground truth mask', 'img_data': gt_mask_car_vertical_arr1 }, { 'title': 'Car 1 Vertical - Segmentation mask', 'img_data': pred_mask_car_vertical_arr1})

Intersection over Union -> car1         : 0.42698912916611326
Intersection over Union -> car1 vertical: 0.6170763260025873

# Get segmentation mask image
car3_vertical, pred_mask_car_vertical_arr3 = semantic_segmentation(model, './images/car3_vertical.png', min_prob=0.95)
car3_cut, pred_mask_car_cut_arr3 = semantic_segmentation(model, './images/car3_cut.png', min_prob=0.95)
car3_cut_vertical, pred_mask_car_cut_vertical_arr3 = semantic_segmentation(model, './images/car3_cut_vertical.png', min_prob=0.95)

# Load ground truth image
_, gt_mask_car_vertical_arr3 = get_img_with_arr('./images/car3_vertical_ground_truth.png', as_binary=True)
_, gt_mask_car_cut_arr3 = get_img_with_arr('./images/car3_cut_ground_truth.png', as_binary=True)
_, gt_mask_car_cut_vertical_arr3 = get_img_with_arr('./images/car3_cut_vertical_ground_truth.png', as_binary=True)

# Ground Truth - Calculate Intersection over Union
print('Intersection over Union -> car3             : ' + str(calculate_iou(pred_mask_car_arr3, gt_mask_car_arr3)))
print('Intersection over Union -> car3 vertical    : ' + str(calculate_iou(pred_mask_car_vertical_arr3, gt_mask_car_vertical_arr3)))
print('Intersection over Union -> car3 cut         : ' + str(calculate_iou(pred_mask_car_cut_arr3, gt_mask_car_cut_arr3)))
print('Intersection over Union -> car3 cut vertical: ' + str(calculate_iou(pred_mask_car_cut_vertical_arr3, gt_mask_car_cut_vertical_arr3)))

# Display original image and masks
show_images({ 'title': 'Car 3 - Original', 'img_data': car3 }, { 'title': 'Car 3 - Ground truth mask', 'img_data': gt_mask_car_arr3 }, { 'title': 'Car 3 - Segmentation mask', 'img_data': pred_mask_car_arr3})
show_images({ 'title': 'Car 3 Vertical - Original', 'img_data': car3_vertical }, { 'title': 'Car 3 Vertical - Ground truth mask', 'img_data': gt_mask_car_vertical_arr3 }, { 'title': 'Car 3 Vertical - Segmentation mask', 'img_data': pred_mask_car_vertical_arr3})
show_images({ 'title': 'Car 3 Cut - Original', 'img_data': car3_cut }, { 'title': 'Car 3 Cut - Ground truth mask', 'img_data': gt_mask_car_cut_arr3 }, { 'title': 'Car 3 Cut - Segmentation mask', 'img_data': pred_mask_car_cut_arr3})
show_images({ 'title': 'Car 3 Cut Vertical - Original', 'img_data': car3_cut_vertical }, { 'title': 'Car 3 Cut Vertical - Ground truth mask', 'img_data': gt_mask_car_cut_vertical_arr3 }, { 'title': 'Car 3 Cut Vertical - Segmentation mask', 'img_data': pred_mask_car_cut_vertical_arr3})

Intersection over Union -> car3             : 0.2905132270863938
Intersection over Union -> car3 vertical    : 0.34255885028883126
Intersection over Union -> car3 cut         : 0.2670574103759522
Intersection over Union -> car3 cut vertical: 0.690153057947414

from torchvision.io.image import decode_image
from torchvision.models.segmentation import LRASPP_MobileNet_V3_Large_Weights, lraspp_mobilenet_v3_large
from torchvision.transforms.functional import to_pil_image
import torchvision.transforms as transforms
import torch
import matplotlib.pyplot as plt
import numpy as np

# Validamos si nuestra computadora soporta CUDA o solo CPU y lo guardamos en una variable
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"

# Usamos los pesos del modelo pre entrenado e iniciamos el modelo indicando el DEVICE que usará.
weights = LRASPP_MobileNet_V3_Large_Weights.COCO_WITH_VOC_LABELS_V1;
model = lraspp_mobilenet_v3_large(weights=weights).to(DEVICE)

# Activamos el modo de evaluación del modelo, esto implica cambiar el comportamiento interno de las capas.
_ = model.eval()

# open_tensor_image: función que nos ayuda a abrir una imagen y devuelve un torch.Tensor con la forma [C, H, W] (canal, alto, ancho)
# inputs:
#    path: ruta de la imagen
def open_tensor_image(path, as_binary=False):
    # Abrimos la imagen como tensor usando decode_image
    img = decode_image(path)

    if as_binary:
        return to_pil_image(img).convert('1')
    
    # si la imagen tiene 4 canales, sobreescribimos para solo dejar 3.
    if img.shape[0] == 4:
        img = img[:3, :, :]

    return img

# process_tensor_image: función que nos ayuda a pre procesar una imagen torch.Tensor. Devuelve la imagen normalizada.
# inputs:
#    img: imagen del tipo torch.Tensor
def process_tensor_image(img):
    # Creamos un pipeline de transformaciones para usar con la imagen.
    transform = transforms.Compose([
        # Convertimos los valores a float para su posterior normalización
        transforms.ConvertImageDtype(torch.float),
        # Operación para normalizar la imagen.
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                             std=[0.229, 0.224, 0.225])
    ])

    # Transformamos la imagen y el resultado lo asignamos a una nueva variable.
    img_tensor = transform(img)

    # Agregamos una nueva dimensión en la posición 0 ya que es el formato que espera cualquier modelo de pytorch. Despues movemos el tensor al dispositivo donde será procesado, "cuda" o "cpu".
    img_tensor = img_tensor.unsqueeze(0).to(DEVICE)

    return img_tensor

# image_segmentation: Función que nos ayuda a ejecutar el modelo sobre una imagen dada. Devuelve la mascara binarizada y la mascara predicha por el modelo.
# inputs:
#     img: imagen del tipo torch.Tensor
def image_segmentation(img):
    # Obtenemos las clases desde los pesos y convertimos la lista en un diccionario.
    class_to_idx = {cls: idx for (idx, cls) in enumerate(weights.meta["categories"])}

    # Obtenemos el indice de la clase __background__
    category = class_to_idx["__background__"]

    # Le indicamos a PyTorch que no almacene los gradientes, para mejorar el desempeño de la predicción.
    with torch.no_grad():
        # Usamos el modelo para hacer la predicción y obtenemos el resultado.
        prediction = model(img)["out"]

        # Usamos softmax a lo largo del eje dim=1.
        prediction_image = prediction.softmax(dim=1)

        # Obtenemos la mascara predicha por el modelo usando la categoria obtenida anteriormente.
        predicted_mask = prediction_image[0, category].cpu()

    # Creamos una mascara binaria con todo aquello que tenga menos del 95% de probabilidad de ser el background de la imagen.
    binary_mask = (predicted_mask < 0.95).float()

    # Retornamos la mascara binarizada y la mascara predicha.
    return binary_mask, predicted_mask.detach().cpu().numpy()

# show_images: Función que nos permite mostrar la imagen original, la mascara binarizada, la mascara predicha y el ground truth
# inputs:
#    img: Imagen original.
#    binary_mask: Imagen de mascara binarizada.
#    predicted_mask: Imagen de mascara predicha
#    ground_truth: Imagen de ground truth
def show_images(img, binary_mask, predicted_mask, ground_truth):
    plt.figure(figsize=(20,4))
    plt.subplot(1,4,1)
    plt.imshow(img.permute(1, 2, 0).cpu().numpy())
    plt.title("Imagen original")
    plt.subplot(1,4,2)
    plt.title(f"Ground Truth")
    plt.imshow(ground_truth, cmap='gray')
    plt.subplot(1,4,3)
    plt.title(f"Máscara binarizada")
    plt.imshow(binary_mask, cmap='gray')
    plt.subplot(1,4,4)
    plt.title(f"Mascara predicha")
    plt.imshow(predicted_mask, cmap='gray')
    plt.show()

# calculate_iou: Función que nos permite calcular que tanto se sobrepone la mascara binarizada sobre el ground truth.
# inputs:
#    pred: mascara predicha
#    gt: mascara Ground truth
def calculate_iou(pred, gt):
    pred_np = pred.cpu().numpy() if torch.is_tensor(pred) else pred
    gt_np = gt.cpu().numpy() if torch.is_tensor(gt) else gt
    intersection = np.logical_and(pred_np, gt_np).sum()
    union = np.logical_or(pred_np, gt_np).sum()
    return intersection / union if union != 0 else 0.0

car1 = open_tensor_image('./images/car1.png')
car1_ground_truth = open_tensor_image('./images/car1_ground_truth.png', True)
car1_preproc = process_tensor_image(car1)
binary_mask, predicted_mask = image_segmentation(car1_preproc)
print('Porcentaje de predicción: ', calculate_iou(binary_mask, car1_ground_truth))
show_images(car1, binary_mask, predicted_mask, car1_ground_truth)

Porcentaje de predicción:  0.41288091694358137

car2 = open_tensor_image('./images/car2.png')
car2_ground_truth = open_tensor_image('./images/car2_ground_truth.png', True)
car2_preproc = process_tensor_image(car2)
binary_mask, predicted_mask = image_segmentation(car2_preproc)
print('Porcentaje de predicción: ', calculate_iou(binary_mask, car2_ground_truth))
show_images(car2, binary_mask, predicted_mask, car2_ground_truth)

Porcentaje de predicción:  0.4290434596380658

car3 = open_tensor_image('./images/car3.jpg')
car3_ground_truth = open_tensor_image('./images/car3_ground_truth.png', True)
car3_preproc = process_tensor_image(car3)
binary_mask, predicted_mask = image_segmentation(car3_preproc)
print('Porcentaje de predicción: ', calculate_iou(binary_mask, car3_ground_truth))
show_images(car3, binary_mask, predicted_mask, car3_ground_truth)

Porcentaje de predicción:  0.3613564358289406

# Nos permite liberar la memoria utilizada en la GPU y limpiar el caché.
torch.cuda.empty_cache()

!pip install -q ultralytics

from ultralytics import YOLO
import cv2
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np
import os
from glob import glob
from google.colab import drive
drive.mount('/content/drive')

Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).

model = YOLO("yolov8s-seg.pt")

image_paths = [
    "/content/drive/MyDrive/imagenesColab/Cars/car1.png",
    "/content/drive/MyDrive/imagenesColab/Cars/car2.png",
    "/content/drive/MyDrive/imagenesColab/Cars/car3.png"
]
images = [cv2.cvtColor(cv2.imread(p), cv2.COLOR_BGR2RGB) for p in image_paths]

results_list = [model(p)[0] for p in image_paths]
annotated_images = []

for img, res in zip(images, results_list):
    annotated = img.copy()
    height, width = annotated.shape[:2]

    if res.masks is not None: #Verificamos que el resultado "res" contenga máscaras segmentadas
        for mask in res.masks.data: #iteración sobre cada máscara
            mask_np = mask.cpu().numpy()
            resized_mask = cv2.resize(mask_np, (width, height), interpolation=cv2.INTER_NEAREST) #mantenemos la interpolacion binaria
            color_mask = np.zeros_like(annotated)
            color_mask[resized_mask > 0.3] = [0, 255, 0] #pintanos de verde los píxeles de la mascara binaria
            annotated = cv2.addWeighted(annotated, 1.0, color_mask, 0.5, 0) #se superpone la mascara sobre la imagen

    annotated_images.append(annotated)


plt.figure(figsize=(15, 5))
for i, img in enumerate(annotated_images):
    plt.subplot(1, len(annotated_images), i + 1)
    plt.imshow(img)
    plt.axis("off")
    plt.title(f"Máscaras segmentadas - Imagen {i+1}")
plt.tight_layout()
plt.show()

image 1/1 /content/drive/MyDrive/imagenesColab/Cars/car1.png: 416x640 2 cars, 572.7ms
Speed: 2.0ms preprocess, 572.7ms inference, 7.0ms postprocess per image at shape (1, 3, 416, 640)

image 1/1 /content/drive/MyDrive/imagenesColab/Cars/car2.png: 448x640 1 car, 7 cell phones, 876.6ms
Speed: 2.5ms preprocess, 876.6ms inference, 22.5ms postprocess per image at shape (1, 3, 448, 640)

image 1/1 /content/drive/MyDrive/imagenesColab/Cars/car3.png: 448x640 1 bottle, 14 cell phones, 691.2ms
Speed: 3.0ms preprocess, 691.2ms inference, 41.4ms postprocess per image at shape (1, 3, 448, 640)

output_dir = "/content/drive/MyDrive/imagenesColab/Cars/ground_truth"
os.makedirs(output_dir, exist_ok=True) #crea el directorio en Google Drive si es que no existe

for idx, (res, path) in enumerate(zip(results_list, image_paths)): #itera sobre los resultados de la segmentación generados por el modelo y por las rutas de las imagenes
    filename = os.path.splitext(os.path.basename(path))[0] #obtenemos el nombre del archivo sin extensión

    if res.masks is not None: #verificamos si hay realmente máscaras
        mask_combined = np.zeros(res.masks.data[0].shape, dtype=np.uint8) #se inicia una mascara vacía para combinarlas todas
        for mask in res.masks.data:
            mask_np = (mask.cpu().numpy() > 0.5).astype("uint8") #se aplica umbral de 0.5 para binarizar la máscara
            mask_combined = np.logical_or(mask_combined, mask_np) #se va acumulando las máscaras en una sola

        mask_combined = (mask_combined * 255).astype("uint8") #se convuerte la mascara binaria a escala de grises
        output_path = os.path.join(output_dir, f"{filename}_pred.png") #conbtruye la ruta final del archivo
        cv2.imwrite(output_path, mask_combined) #usamos OpenCV para guardar la imagen en formato png
        print(f"Guardada: {output_path}") #imprimimos si fue gyardado con exito el archivo

Guardada: /content/drive/MyDrive/imagenesColab/Cars/ground_truth/car1_pred.png
Guardada: /content/drive/MyDrive/imagenesColab/Cars/ground_truth/car2_pred.png
Guardada: /content/drive/MyDrive/imagenesColab/Cars/ground_truth/car3_pred.png

ground_truth_dir = "/content/drive/MyDrive/imagenesColab/Cars/ground_truth" #definimos la ruta de las mascaras ground truth en Google Drive

gt_paths = sorted(glob(os.path.join(ground_truth_dir, "*[!_pred].png"))) #buscamos las imagenes que no contienen _pred como sufijo

plt.figure(figsize=(5 * len(gt_paths), 5))
for i, gt_path in enumerate(gt_paths):
    mask = Image.open(gt_path).convert("L")
    plt.subplot(1, len(gt_paths), i + 1)
    plt.imshow(mask, cmap='gray')
    plt.title(f"Ground Truth - Imagen {i+1}")
    plt.axis("off")
plt.tight_layout()
plt.show()

from glob import glob #permite buscar archivos que coincidan con un patrón

def calculate_iou(mask_pred, mask_gt): #compara las dos máscaras binarias
    intersection = np.logical_and(mask_pred, mask_gt).sum() #cantidad de píxeles donde ambas máscaras tienen valor positivo
    union = np.logical_or(mask_pred, mask_gt).sum() #cantidad de píxeles donde al menos una máscara es positiva
    return intersection / union if union > 0 else float('nan')

ground_truth_dir = "/content/drive/MyDrive/imagenesColab/Cars/ground_truth" #ruta de archivos de imagenes a comparar
ious = []

for gt_path in sorted(glob(os.path.join(ground_truth_dir, "*[!_pred].png"))): #iteración sobre las imagenes ground truth
    filename = os.path.basename(gt_path)
    name_base = filename.replace(".png", "")
    pred_path = os.path.join(ground_truth_dir, f"{name_base}_pred.png") #busca el archivo de máscara predicha correspondiente

    if os.path.exists(pred_path): #procede si encontró una máscara predicha
        mask_gt = np.array(Image.open(gt_path).convert("L")) #se cargan las imagenes en escala de grises
        mask_pred = np.array(Image.open(pred_path).convert("L"))
        mask_pred = cv2.resize(mask_pred, (mask_gt.shape[1], mask_gt.shape[0]), interpolation=cv2.INTER_NEAREST) #nos aseguramos que las imagenes tengan el mismo tamaño

        mask_gt_bin = mask_gt > 127 #convierte las máscaras de escala de grises a binarias usando umbral 127
        mask_pred_bin = mask_pred > 127

        iou = calculate_iou(mask_pred_bin, mask_gt_bin) #calcula la métrica del IoU
        ious.append(iou)
        print(f"IoU para {filename}: {iou:.3f}") #lmuestra el resuluado
    else:
        print(f"No se encontró predicción para {filename}") #se notifica si no existe

if ious:
    print(f"\nIoU promedio: {np.nanmean(ious):.3f}") #se muestra el promedio final
else:
    print("No se encontraron comparaciones válidas.") #mensaje si no se encontró ninguna

IoU para car1.png: 0.024
IoU para car2.png: 0.866
IoU para car3.png: 0.229

IoU promedio: 0.373

Actividad 3 - Segmentación de Imagenes¶

Objetivo¶

Segmentación semántica¶

Ground truth para validar modelos de segmentación¶

Segmentación semántica de autos con DeepLabv3 Resnet101¶

Código¶

Resultados de segmentación semántica con DeepLabV3 Resnet101¶

Conclusiones DeepLabV3¶

Segmentación semántica con LRASPP Mobilenet¶

¿Qué es lraspp_mobilenet_v3_large?¶

MobileNetV3-Large¶

Características clave:¶

LR-ASPP (Lite Reduced Atrous Spatial Pyramid Pooling)¶

¿Qué hace?¶

COCO_WITH_VOC_LABELS_V1 (en torchvision.models.segmentation)¶

¿Qué significa?¶

¿Qué contiene este conjunto de pesos?¶

Clases que incluye¶

Implementación¶

Imports¶

Preparación del modelo¶

Funciones útiles¶

Aplicamos el modelo a la imagen car1.png¶

Aplicamos el modelo a la imagen car2.png¶

Aplicamos el modelo a la imagen car3.jpg¶

Conclusión¶

Segmentación con YOLOv8¶

Implementación¶

Conclusiones YOLOv8¶

Conclusiones generales¶